// 个人中心页面逻辑
const app = getApp()
const AvatarUtils = require('../../utils/avatarUtils')

Page({
  data: {
    userInfo: null,
    totalScore: 0,
    roomHistory: [],
    loading: false,
    currentRoom: null,
    currentScore: 0,
    currentTime: '',
    historyRecords: [],
    roomBalance: [],
    profileAds: [], // 添加广告数据
    refreshing: false // 下拉刷新状态
  },

  onLoad() {
    this.getUserInfo()
    this.getRoomHistory()
    this.getCurrentStatus()
    this.getHistoryRecords()
    this.updateCurrentTime()
    this.loadProfileAds() // 加载个人中心广告
  },

  onShow() {
    console.log('profile页面显示，刷新状态')
    
    // 先获取用户信息
    this.getUserInfo()
    
    // 强制刷新当前状态，确保获取最新数据
    this.getCurrentStatus()
    
    // 更新tabbar状态
    this.updateTabbarStatus()
    
    // 如果有房间数据，立即验证服务器状态获取最新盈利情况
    const RoomCache = require('../../utils/roomCache')
    const currentRoom = RoomCache.getRoomBasicInfo()
    const userInfo = wx.getStorageSync('userInfo')
    
    if (currentRoom && currentRoom.id && userInfo && userInfo.id) {
      console.log('立即验证房间状态获取最新盈利情况')
      this.verifyRoomStatusWithServer(currentRoom.id, userInfo.id)
      
      // 额外调用强制刷新盈利状态，确保获取最新数据
      setTimeout(() => {
        this.forceRefreshProfitStatus()
      }, 500)
    }
    
    console.log('profile页面状态刷新完成')
  },

  // 强制刷新盈利状态
  forceRefreshProfitStatus() {
    console.log('强制刷新盈利状态')
    const RoomCache = require('../../utils/roomCache')
    const currentRoom = RoomCache.getRoomBasicInfo()
    const userInfo = wx.getStorageSync('userInfo')
    
    if (currentRoom && currentRoom.id && userInfo && userInfo.id) {
      // 立即向服务器请求最新状态
      wx.request({
        url: `${app.globalData.baseUrl}/api/room/roomStatus`,
        method: 'POST',
        data: {
          user_id: userInfo.id,
          room_id: currentRoom.id
        },
        success: (res) => {
          console.log('强制刷新盈利状态结果:', res.data)
          if (res.data && res.data.success && res.data.data) {
            const latestScore = res.data.data.current_score || 0
            console.log('获取到最新分数:', latestScore)
            
            // 更新缓存
            RoomCache.saveScore(latestScore)
            
            // 更新页面显示
            this.setData({
              currentScore: latestScore
            })
            
            // 获取房间收支情况
            this.getRoomBalance(currentRoom.id)
          }
        },
        fail: (err) => {
          console.error('强制刷新盈利状态失败:', err)
        }
      })
    }
  },

  onHide() {
    // 个人中心页面隐藏时无需特殊处理
  },

  // 下拉刷新
  onPullRefresh() {
    console.log('开始下拉刷新')
    this.setData({ refreshing: true })
    
    // 刷新用户信息
    this.refreshUserInfo()
    
    // 刷新房间状态（从服务器获取最新数据）
    this.refreshRoomStatus()
    
    // 刷新房间历史
    this.getRoomHistory()
    
    // 刷新广告
    this.loadProfileAds()
    
    // 延迟结束刷新状态
    setTimeout(() => {
      this.setData({ refreshing: false })
      console.log('下拉刷新完成')
    }, 1000)
  },

  // 刷新用户信息
  refreshUserInfo() {
    const userInfo = wx.getStorageSync('userInfo')
    if (!userInfo) return

    // 从服务器获取最新用户信息
    wx.request({
      url: `${app.globalData.baseUrl}/api/user/info`,
      method: 'GET',
      data: { user_id: userInfo.id },
      success: (res) => {
        if (res.data.success && res.data.data) {
          const updatedUserInfo = res.data.data
          this.setData({ 
            userInfo: updatedUserInfo,
            totalScore: updatedUserInfo.total_score || 0
          })
          // 更新本地存储
          wx.setStorageSync('userInfo', updatedUserInfo)
          console.log('用户信息已更新:', updatedUserInfo)
        }
      },
      fail: (err) => {
        console.error('刷新用户信息失败:', err)
        // 如果API失败，至少从本地缓存获取
        this.getUserInfo()
      }
    })
  },

  // 刷新房间状态（从服务器获取最新数据）
  refreshRoomStatus() {
    console.log('开始刷新房间状态')
    const userInfo = wx.getStorageSync('userInfo')
    if (!userInfo) return

    const RoomCache = require('../../utils/roomCache')
    const roomData = RoomCache.getRoomBasicInfo()
    
    if (!roomData || !roomData.id) {
      console.log('没有房间数据，清除状态')
      this.setData({
        currentRoom: null,
        currentScore: 0,
        roomBalance: []
      })
      return
    }

    // 从服务器获取最新的房间状态
    wx.request({
      url: `${app.globalData.baseUrl}/api/room/get-by-code`,
      method: 'GET',
      data: { room_code: roomData.room_code },
      success: (res) => {
        if (res.data.success && res.data.data) {
          const latestRoomData = res.data.data
          const currentUser = latestRoomData.users?.find(user => user.id === userInfo.id)
          
          if (currentUser) {
            // 更新当前用户分数
            const newScore = currentUser.current_score || 0
            this.setData({
              currentRoom: {
                id: latestRoomData.id,
                name: latestRoomData.name,
                room_code: latestRoomData.room_code,
                is_settled: latestRoomData.status === 'finished'
              },
              currentScore: newScore
            })
            
            // 更新本地缓存
            RoomCache.saveScore(newScore)
            console.log('房间状态已更新，新分数:', newScore)
          } else {
            console.log('用户不在房间中，清除状态')
            this.setData({
              currentRoom: null,
              currentScore: 0,
              roomBalance: []
            })
            RoomCache.clearRoom()
          }
        } else {
          console.log('获取房间信息失败，清除状态')
          this.setData({
            currentRoom: null,
            currentScore: 0,
            roomBalance: []
          })
          RoomCache.clearRoom()
        }
      },
      fail: (err) => {
        console.error('刷新房间状态失败:', err)
        // 失败时使用本地缓存
        this.getCurrentStatus()
      }
    })
  },

  // 分享给好友
  async onShareAppMessage() {
    const ShareUtil = require('../../utils/shareUtil')
    return await ShareUtil.generateShareAppMessageConfig('profile', {
      userInfo: this.data.userInfo,
      totalScore: this.data.totalScore
    })
  },

  // 分享到朋友圈
  async onShareTimeline() {
    const ShareUtil = require('../../utils/shareUtil')
    return await ShareUtil.generateShareTimelineConfig('profile', {
      userInfo: this.data.userInfo,
      totalScore: this.data.totalScore
    })
  },


  // 获取用户信息
  getUserInfo() {
    const userInfo = wx.getStorageSync('userInfo')
    
    if (userInfo && userInfo.id) {
      this.setUserInfo(userInfo)
    } else {
      this.setData({ 
        userInfo: null,
        totalScore: 0
      })
      
      // 显示登录提示
      wx.showModal({
        title: '未登录',
        content: '请先登录后再使用此功能',
        showCancel: false,
        success: () => {
          wx.navigateTo({
            url: '/pages/index/index'
          });
        }
      });
    }
  },

  // 设置用户信息，处理头像URL
  setUserInfo(user) {
    if (user && user.avatar && !user.avatar.startsWith('http')) {
      user.avatarUrl = getApp().globalData.baseUrl + user.avatar
    } else {
      user.avatarUrl = user?.avatar || ''
    }
    this.setData({ 
      userInfo: user,
      totalScore: user.total_score || 0
    })
  },

  // 获取当前状态
  getCurrentStatus() {
    const userInfo = wx.getStorageSync('userInfo')
    if (!userInfo) return

    const RoomCache = require('../../utils/roomCache')
    const roomData = RoomCache.getRoomBasicInfo()
    const currentScore = RoomCache.getScore()
    
    console.log('获取当前状态 - roomData:', roomData)
    console.log('获取当前状态 - currentScore:', currentScore)
    
    // 首先根据缓存设置基本状态
    if (roomData && roomData.id) {
      this.setData({
        currentRoom: roomData,
        currentScore: currentScore
      })
      // 获取房间收支情况
      this.getRoomBalance(roomData.id)
    } else {
      this.setData({
        currentRoom: null,
        currentScore: 0,
        roomBalance: []
      })
    }
    
    // 更新tabbar状态
    this.updateTabbarStatus()
    
    // 向服务器验证房间状态，只有在有房间数据和用户ID时才验证
    if (roomData && roomData.id && userInfo && userInfo.id) {
      console.log('验证房间状态:', roomData.id, userInfo.id)
      this.verifyRoomStatusWithServer(roomData.id, userInfo.id)
    }
  },
  
  // 向服务器验证房间状态
  verifyRoomStatusWithServer(roomId, userId) {
    try {
      const RoomCache = require('../../utils/roomCache')
      // 在方法内重新获取房间数据，确保作用域正确
      const currentRoomData = RoomCache.getRoomBasicInfo()
      
      // 确保roomId是有效的
      if (!roomId) {
        console.warn('房间ID无效，跳过验证')
        return
      }
      
      wx.request({
        // 注意：路由配置在/api/room路径下，而不是/api/user
        url: `${app.globalData.baseUrl}/api/room/roomStatus`,
        method: 'POST',
        data: {
          user_id: userId,
          room_id: roomId
        },
        success: (res) => {
          try {
            console.log('服务器验证房间状态结果:', res.data)
            
            // 安全检查：确保响应数据结构正确
            if (!res.data || typeof res.data !== 'object') {
              console.error('响应数据格式错误:', res.data)
              return
            }
            
            // 确保res.data.data存在
            if (!res.data.data || typeof res.data.data !== 'object') {
              console.error('响应数据data字段缺失或格式错误:', res.data)
              return
            }
            
            // 如果后端返回不在房间中，清除本地缓存
            if (res.data.success && !res.data.data.inRoom) {
              console.log('服务器返回用户已不在房间中，清除本地缓存')
              RoomCache.clearRoom()
              
              this.setData({
                currentRoom: null,
                currentScore: 0,
                roomBalance: []
              })
              
              // 更新tabbar状态
              this.updateTabbarStatus()
            } else if (currentRoomData) {
              // 如果确实在房间中，更新页面状态
              console.log('服务器确认用户在房间中')
              
              // 获取最新的分数信息
              const latestScore = res.data.data.current_score || RoomCache.getScore()
              console.log('服务器返回的最新分数:', latestScore)
              
              // 更新缓存中的分数
              RoomCache.saveScore(latestScore)
              
              this.setData({
                currentRoom: currentRoomData,
                currentScore: latestScore
              })
              
              // 获取房间收支情况，使用传入的roomId
              this.getRoomBalance(roomId)
            }
          } catch (successError) {
            console.error('处理响应成功时出错:', successError)
          }
        },
        fail: (err) => {
          console.error('验证房间状态失败:', err)
          // 网络请求失败时，基于本地缓存显示
          try {
            if (currentRoomData) {
              this.setData({
                currentRoom: currentRoomData,
                currentScore: RoomCache.getScore()
              })
              // 安全检查：确保currentRoomData.id存在
              if (currentRoomData.id) {
                this.getRoomBalance(currentRoomData.id)
              }
            }
          } catch (failError) {
            console.error('处理响应失败时出错:', failError)
          }
        }
      })
    } catch (error) {
      console.error('验证房间状态过程中出错:', error)
    }
  },

  // 更新时间
  updateCurrentTime() {
    const now = new Date()
    const timeStr = `${now.getHours().toString().padStart(2, '0')}:${now.getMinutes().toString().padStart(2, '0')}`
    this.setData({ currentTime: timeStr })
    
    // 每分钟更新一次时间
    setTimeout(() => {
      this.updateCurrentTime()
    }, 60000)
  },

  // 获取历史记录
  getHistoryRecords() {
    const userInfo = wx.getStorageSync('userInfo')
    if (!userInfo || !userInfo.id) {
      return
    }

    wx.request({
      url: `${app.globalData.baseUrl}/api/user/records`,
      method: 'GET',
      data: {
        user_id: userInfo.id,
        page: 1,
        page_size: 10
      },
      success: (res) => {
        if (res.data.success && res.data.data.records) {
          // 格式化记录数据
          const records = res.data.data.records.map(record => {
            const dateTime = record.date.split(' ')
            return {
              id: record.id,
              date: dateTime[0] || '',
              time: dateTime[1] || '',
              room_code: record.room_code || '',
              description: record.description || `${record.room_name || ''}(${Math.abs(record.score_change || 0)})`,
              type: record.result || 'draw',
              result_type: record.result || 'draw',
              result: record.result === 'win' ? '赢' : record.result === 'loss' ? '输' : '平',
              score: Math.abs(record.score_change || 0)
            }
          })
          
          this.setData({ historyRecords: records })
        } else {
          this.setData({ historyRecords: [] })
        }
      },
      fail: (err) => {
        console.error('获取历史记录失败:', err)
        this.setData({ historyRecords: [] })
      }
    })
  },

  // 获取房间收支情况
  getRoomBalance(roomId) {
    if (!roomId) return
    
    const userInfo = wx.getStorageSync('userInfo')
    if (!userInfo || !userInfo.id) {
      return
    }

    wx.request({
      url: `${app.globalData.baseUrl}/api/accounting/room-settlement`,
      method: 'GET',
      data: {
        room_id: roomId,
        user_id: userInfo.id
      },
      success: (res) => {
        if (res.data.success && res.data.data && res.data.data.settlement_data) {
          // 格式化结算数据
          const balance = res.data.data.settlement_data.map(item => {
            return {
              id: item.user_id,
              nickname: item.user_name || '未知用户',
              avatar: '', // 可以从用户信息中获取
              score: item.total_score || 0,
              isCurrentUser: item.user_id === userInfo.id
            }
          })
          
          this.setData({ roomBalance: balance })
        } else {
          this.setData({ roomBalance: [] })
        }
      },
      fail: (err) => {
        console.error('获取房间收支情况失败:', err)
        this.setData({ roomBalance: [] })
      }
    })
  },

  // 获取房间历史
  getRoomHistory() {
    const userInfo = wx.getStorageSync('userInfo')
    if (!userInfo) return

    this.setData({ loading: true })
    wx.request({
      url: `${app.globalData.baseUrl}/api/user/room-history`,
      method: 'GET',
      data: { user_id: userInfo.id },
      success: (res) => {
        if (res.data.success) {
          this.setData({ roomHistory: res.data.data.history })
        }
      },
      complete: () => {
        this.setData({ loading: false })
      }
    })
  },

  // 更新用户信息
  updateUserInfo() {
    const userInfo = this.data.userInfo
    if (!userInfo) {
      wx.showToast({
        title: '请先登录',
        icon: 'none'
      });
      return;
    }

    wx.showActionSheet({
      itemList: ['修改头像', '修改昵称'],
      success: (res) => {
        if (res.tapIndex === 0) {
          this.chooseAvatar()
        } else if (res.tapIndex === 1) {
          this.updateNickname()
        }
      }
    })
  },

  // 选择头像 - 使用头像工具类
  chooseAvatar() {
    AvatarUtils.showAvatarChooseModal(
      (avatarPath) => {
        // 头像选择成功，开始上传
        this.doUpdateUserInfo(this.data.userInfo.nickname, avatarPath)
      },
      (err) => {
        console.error('头像选择失败:', err);
        AvatarUtils.showError('选择头像失败')
      }
    )
  },



  // 跳转到登录页面
  goToLogin() {
    wx.navigateTo({
      url: '/pages/index/index'
    });
  },

  // 修改昵称
  updateNickname() {
    const userInfo = this.data.userInfo
    if (!userInfo) {
      wx.showToast({
        title: '请先登录',
        icon: 'none'
      });
      return;
    }
    
    wx.showModal({
      title: '修改昵称',
      content: '',
      editable: true,
      placeholderText: userInfo.nickname,
      success: (res) => {
        if (res.confirm && res.content && res.content.trim()) {
          this.doUpdateUserInfo(res.content.trim(), userInfo.avatar)
        }
      }
    })
  },

  // 执行更新用户信息
  doUpdateUserInfo(nickname, avatar) {
    wx.showLoading({ title: '更新中...' })
    
    // 如果上传头像，先上传到服务器
    if (avatar && avatar !== this.data.userInfo.avatar) {
      this.uploadAvatar(avatar, nickname)
    } else {
      this.updateUserData(nickname, this.data.userInfo.avatar)
    }
  },

  // 上传头像 - 使用头像工具类
  uploadAvatar(avatarPath, nickname) {
    AvatarUtils.uploadAvatar(
      avatarPath,
      this.data.userInfo.id,
      (avatarUrl, responseData) => {
        // 上传成功，直接更新用户信息
        AvatarUtils.showSuccess('头像上传成功')
        
        // 确保头像URL是完整的URL
        let finalAvatarUrl = avatarUrl;
        if (avatarUrl.startsWith('/')) {
          finalAvatarUrl = app.globalData.baseUrl + avatarUrl;
        }
        
        // 更新本地用户信息
        const updatedUserInfo = {
          ...this.data.userInfo,
          avatar: finalAvatarUrl,
          nickname: nickname
        }
        
        // 更新页面数据
        this.setData({ userInfo: updatedUserInfo })
        
        // 更新本地存储
        wx.setStorageSync('userInfo', updatedUserInfo)
        
        // 更新全局用户信息
        app.setLoginStatus(updatedUserInfo)
      },
      (err) => {
        // 上传失败
        const errorMessage = err.message || err.errMsg || '头像上传失败'
        AvatarUtils.showError(errorMessage)
      }
    )
  },


  // 更新用户数据
  updateUserData(nickname, avatar) {
    wx.request({
      url: `${app.globalData.baseUrl}/api/user/create-or-update`,
      method: 'POST',
      data: {
        wechat_openid: this.data.userInfo.wechat_openid,
        nickname: nickname,
        avatar: avatar
      },
      success: (res) => {
        if (res.data.success) {
          const user = res.data.data.user
          this.setUserInfo(user)
          wx.setStorageSync('userInfo', user)
          wx.showToast({
            title: '更新成功',
            icon: 'success'
          })
        } else {
          wx.showToast({
            title: res.data.message || '更新失败',
            icon: 'none'
          })
        }
      },
      complete: () => {
        wx.hideLoading()
      }
    })
  },

  // 查看房间详情
  viewRoom(e) {
    const roomCode = e.currentTarget.dataset.roomCode
    wx.navigateTo({
      url: `/pages/room/room?roomCode=${roomCode}`
    })
  },

  // 退出登录
  logout() {
    wx.showModal({
      title: '确认退出',
      content: '确定要退出登录吗？',
      success: (res) => {
        if (res.confirm) {
          wx.removeStorageSync('userInfo')
          wx.reLaunch({
            url: '/pages/index/index'
          })
        }
      }
    })
  },

  // 联系客服
  contactService() {
    wx.showModal({
      title: '联系客服',
      content: '如有问题，请联系客服微信：service123',
      showCancel: false
    })
  },

  // 关于我们
  aboutUs() {
    wx.showModal({
      title: '关于我们',
      content: '打牌记账小程序\n版本：1.0.0\n\n本应用不涉及金钱，仅用于娱乐记账。',
      showCancel: false
    })
  },

  // ========== 结算管理功能 ==========
  
  // 生成结算策略
  generateSettlement() {
    console.log('生成结算策略被调用')
    
    const RoomCache = require('../../utils/roomCache')
    const roomData = RoomCache.getRoomBasicInfo()
    
    console.log('房间数据:', roomData)
    console.log('当前房间状态:', this.data.currentRoom)
    console.log('当前分数:', this.data.currentScore)
    console.log('用户信息:', this.data.userInfo)
    
    // 检查是否有房间数据
    if (!roomData || !roomData.id) {
      console.log('房间数据无效，显示提示并跳转到房间页面')
      wx.showToast({
        title: '请先加入房间',
        icon: 'none',
        duration: 2000
      })
      
      // 延迟跳转到房间页面
      setTimeout(() => {
        wx.navigateTo({
          url: '/pages/room/room'
        })
      }, 2000)
      return
    }
    
    // 检查用户是否在房间中（通过检查当前状态）
    if (!this.data.currentRoom) {
      console.log('用户不在房间中，显示提示并跳转到房间页面')
      wx.showToast({
        title: '请先加入房间',
        icon: 'none',
        duration: 2000
      })
      
      // 延迟跳转到房间页面
      setTimeout(() => {
        wx.navigateTo({
          url: '/pages/room/room'
        })
      }, 2000)
      return
    }
    
    // 跳转到结算策略页面
    wx.navigateTo({
      url: '/pages/settlement-strategy/settlement-strategy'
    })
  },

  // 显示结算策略结果
  showSettlementStrategy(strategyData) {
    const { strategy, message, transfers, total_amount } = strategyData
    
    let content = message + '\n\n'
    
    if (transfers && transfers.length > 0) {
      content += '详细结算信息：\n'
      transfers.forEach((transfer, index) => {
        content += `${index + 1}. ${transfer.from_username} → ${transfer.to_username}: ${transfer.amount}分\n`
      })
    }
    
    if (strategy === 'balanced') {
      content += '\n您无需参与任何结算。'
    } else if (strategy === 'no_records') {
      content += '\n您没有任何交易记录。'
    }
    
    wx.showModal({
      title: '我的结算策略',
      content: content,
      showCancel: true,
      cancelText: '关闭',
      confirmText: '保存结算',
      success: (res) => {
        if (res.confirm) {
          this.saveSettlementStrategy()
        }
      }
    })
  },

  // 保存结算策略
  saveSettlementStrategy() {
    const RoomCache = require('../../utils/roomCache')
    const roomData = RoomCache.getRoomBasicInfo()
    
    wx.showLoading({
      title: '保存结算中...',
      mask: true
    })
    
    wx.request({
      url: `${app.globalData.apiBase}/api/settlement-strategy/save-strategy`,
      method: 'POST',
      data: {
        room_id: roomData.id,
        settlement_type: 'manual',
        settlement_reason: '用户生成结算策略'
      },
      success: (res) => {
        wx.hideLoading()
        console.log('保存策略响应:', res.data)
        
        if (res.data.success) {
          wx.showToast({
            title: '结算已保存',
            icon: 'success',
            duration: 2000
          })
        } else {
          wx.showToast({
            title: res.data.message || '保存结算失败',
            icon: 'none',
            duration: 3000
          })
        }
      },
      fail: (error) => {
        wx.hideLoading()
        console.error('保存结算失败:', error)
        wx.showToast({
          title: '网络错误，请重试',
          icon: 'none',
          duration: 2000
        })
      }
    })
  },

  // 跳转到房间页面
  goToRoom() {
    const RoomCache = require('../../utils/roomCache')
    const roomData = RoomCache.getRoomBasicInfo()
    
    if (!roomData) {
      wx.showToast({
        title: '房间信息不存在',
        icon: 'none'
      })
      return
    }
    
    wx.navigateTo({
      url: '/pages/room/room'
    })
  },

  // 直接退房
  directCheckout() {
    console.log('直接退房方法被调用')
    
    wx.showModal({
      title: '直接退房',
      content: '确定要直接退房吗？未结算的分数将自动处理',
      success: (res) => {
        console.log('用户确认退房:', res.confirm)
        
        if (res.confirm) {
          wx.showLoading({ title: '退房中...' })
          
          // 获取用户信息和房间信息
          const userInfo = wx.getStorageSync('userInfo')
          const RoomCache = require('../../utils/roomCache')
          const roomData = RoomCache.getRoomBasicInfo()
          
          console.log('用户信息:', userInfo)
          console.log('房间信息:', roomData)
          console.log('退房API地址:', `${app.globalData.baseUrl}/api/room/exit`)
          
          try {
            // 发送请求到后端退房
            wx.request({
              url: `${app.globalData.baseUrl}/api/room/exit`,
              method: 'POST',
              data: {
                user_id: userInfo?.id || '',
                room_id: roomData?.id || ''
              },
              success: (res) => {
                console.log('后端退房响应:', res)
              },
              fail: (err) => {
                console.error('退房请求失败:', err)
              },
              complete: () => {
                wx.hideLoading()
                
                // 无论API调用成功与否，都执行强制登出操作
                console.log('开始执行强制登出和缓存清理流程')
                this.performForcefulLogout()
              }
            })
          } catch (error) {
            console.error('退房过程发生异常:', error)
            wx.hideLoading()
            // 发生异常时也执行强制登出操作
            this.performForcefulLogout()
          }
        }
      }
    })
  },
  
  // 执行强制登出操作，确保在跳转后再次验证并清除缓存
  performForcefulLogout() {
    console.log('执行强制登出操作')
    
    try {
      const RoomCache = require('../../utils/roomCache')
      const app = getApp() || {}
      const userInfo = wx.getStorageSync('userInfo') || {}
      
      // 1. 先执行所有可能的缓存清除操作
      console.log('步骤1: 清除所有房间相关缓存')
      // 调用封装的清除方法
      RoomCache.clearRoom()
      
      // 手动清除所有可能存储房间信息的缓存键
      const cacheKeysToRemove = [
        'currentRoom', 'currentScore', 'roomInfo', 'roomCache', 
        'roomData', 'activeRoom', 'userInRoom', 'roomScore'
      ]
      
      cacheKeysToRemove.forEach(key => {
        try {
          wx.removeStorageSync(key)
          console.log(`已清除缓存键: ${key}`)
        } catch (err) {
          console.warn(`清除缓存键 ${key} 失败:`, err)
        }
      })
      
      // 2. 重置页面状态
      console.log('步骤2: 重置页面状态')
      this.setData({
        currentRoom: null,
        currentScore: 0,
        roomBalance: [],
        isInRoom: false,
        roomMembers: [],
        roomActivity: null
      })
      
      // 3. 更新全局状态
      console.log('步骤3: 更新全局状态')
      if (app.globalData) {
        app.globalData.isInRoom = false
        app.globalData.currentRoomId = null
      }
      
      // 4. 更新tabbar状态
      console.log('步骤4: 更新tabbar状态')
      if (this.updateTabbarStatus) {
        this.updateTabbarStatus()
      }
      
      // 5. 延迟跳转，确保所有状态都已更新
      console.log('步骤5: 准备页面跳转')
      setTimeout(() => {
        console.log('执行页面跳转')
        wx.reLaunch({
          url: '/pages/index/index',
          success: () => {
            console.log('页面跳转成功')
            // 6. 跳转成功后再次验证并清理
            setTimeout(() => {
              console.log('跳转后最终验证和清理')
              try {
                // 再次创建一个新的RoomCache实例，确保获取最新状态
                const PostNavRoomCache = require('../../utils/roomCache')
                // 安全地获取房间状态，避免访问未定义属性
                try {
                  const testRoom = PostNavRoomCache.getRoomBasicInfo()
                  console.log('跳转后验证房间状态:', testRoom)
                } catch (getRoomError) {
                  console.error('获取房间状态失败:', getRoomError)
                }
                
                // 最终清理
                PostNavRoomCache.clearRoom()
                
                // 再次清除关键缓存键
                ['currentRoom', 'currentScore', 'roomData'].forEach(key => {
                  try {
                    wx.removeStorageSync(key)
                  } catch (e) {
                    console.warn(`最终清理 ${key} 失败:`, e)
                  }
                })
                
                // 再次检查app.globalData状态
                if (app.globalData) {
                  app.globalData.isInRoom = false
                }
                
                // 显示成功提示
                wx.showToast({ title: '退房成功', icon: 'success', duration: 1500 })
              } catch (finalError) {
                console.error('最终清理过程中出错:', finalError)
                // 即使最终清理出错也要显示成功信息
                wx.showToast({ title: '退房成功', icon: 'success' })
              }
            }, 1000)
          },
          fail: (navigateError) => {
            console.error('页面跳转失败:', navigateError)
            // 即使跳转失败也显示成功信息
            wx.showToast({ title: '退房操作已执行', icon: 'none' })
          }
        })
      }, 600)
    } catch (error) {
      console.error('强制登出过程中出错:', error)
      // 即使出错也要执行跳转
      wx.reLaunch({ 
        url: '/pages/index/index',
        complete: () => {
          wx.showToast({ title: '退房操作已执行', icon: 'none' })
        }
      })
    }
  },

  // 查看房间结算
  viewRoomSettlement() {
    const RoomCache = require('../../utils/roomCache')
    const roomData = RoomCache.getRoomBasicInfo()
    
    if (!roomData) {
      wx.showModal({
        title: '无法查看结算',
        content: '请先加入房间',
        showCancel: false,
        confirmText: '确定'
      })
      return
    }
    
    wx.navigateTo({
      url: `/pages/room-settlement/room-settlement?room_id=${roomData.id}`
    })
  },

  // ========== 数据统计功能 ==========

  // 查看排行榜
  viewLeaderboard() {
    wx.navigateTo({
      url: '/pages/leaderboard/leaderboard'
    })
  },

  // 查看房间流水
  viewRoomFlow() {
    const RoomCache = require('../../utils/roomCache')
    const roomData = RoomCache.getRoomBasicInfo()
    
    if (!roomData) {
      wx.showModal({
        title: '无法查看流水',
        content: '请先加入房间',
        showCancel: false,
        confirmText: '确定'
      })
      return
    }
    
    wx.navigateTo({
      url: `/pages/room-records/room-records?room_id=${roomData.id}`
    })
  },

  // 查看历史房间
  viewHistory() {
    wx.navigateTo({
      url: '/pages/room-history/room-history'
    })
  },

  // ========== 帮助支持功能 ==========

  // 查看使用手册
  viewManual() {
    wx.showModal({
      title: '使用手册',
      content: '使用手册功能正在开发中，敬请期待！',
      showCancel: false
    })
  },

  // 意见反馈
  feedback() {
    wx.showModal({
      title: '意见反馈',
      content: '请选择反馈方式',
      confirmText: '微信反馈',
      cancelText: '应用内反馈',
      success: (res) => {
        if (res.confirm) {
          wx.showModal({
            title: '微信反馈',
            content: '请添加客服微信：feedback123\n备注：意见反馈',
            showCancel: false
          })
        } else {
          wx.showModal({
            title: '应用内反馈',
            content: '应用内反馈功能正在开发中，敬请期待！',
            showCancel: false
          })
        }
      }
    })
  },

  // 更新tabbar状态
  updateTabbarStatus() {
    const tabbarComponent = this.selectComponent('#customTabbar')
    if (tabbarComponent && typeof tabbarComponent.setCurrentPage === 'function') {
      const RoomCache = require('../../utils/roomCache')
      const roomData = RoomCache.getRoomBasicInfo()
      tabbarComponent.updateTabbarStatus(!!roomData)
      // 设置当前页面为选中状态
      tabbarComponent.setCurrentPage()
    }
  },

  // 加载个人中心广告
  loadProfileAds() {
    // 检查本地缓存
    const cachedAds = wx.getStorageSync('profileAds')
    const cacheTime = wx.getStorageSync('profileAdsCacheTime')
    const now = new Date().getTime()
    
    // 如果缓存存在且未过期（1小时），直接使用缓存
    if (cachedAds && cacheTime && (now - cacheTime) < 3600000) {
      this.setData({
        profileAds: cachedAds
      })
      return
    }
    
    // 请求个人中心广告
    wx.request({
      url: `${app.globalData.baseUrl}/api/ad/list`,
      method: 'GET',
      data: {
        position: 'profile',
        status: 'active'
      },
      success: (res) => {
        if (res.data.success && res.data.data.ads) {
          const ads = res.data.data.ads
          this.setData({
            profileAds: ads
          })
          // 缓存广告数据
          wx.setStorageSync('profileAds', ads)
          wx.setStorageSync('profileAdsCacheTime', now)
        } else {
          // 如果没有广告，使用默认广告
          this.setDefaultProfileAds()
        }
      },
      fail: (err) => {
        console.error('获取个人中心广告失败:', err)
        // 使用默认广告
        this.setDefaultProfileAds()
      }
    })
  },
  
  // 设置默认个人中心广告
  setDefaultProfileAds() {
    this.setData({
      profileAds: [{
        id: 1,
        title: '精彩游戏推荐',
        desc: '发现更多有趣游戏',
        image: '/images/ad1.jpg',
        url: 'https://example.com/game1'
      }, {
        id: 2,
        title: '游戏攻略',
        desc: '成为高手的秘密',
        image: '/images/ad2.jpg',
        url: 'https://example.com/strategy'
      }]
    })
  },
  
  // 点击广告
  clickAd(e) {
    const ad = e.currentTarget.dataset.ad
    if (ad && ad.url) {
      // 记录广告点击
      this.recordAdClick(ad.id)
      
      // 跳转到广告链接
      wx.navigateTo({
        url: `/pages/webview/webview?url=${encodeURIComponent(ad.url)}&title=${encodeURIComponent(ad.title)}`
      })
    }
  },
  
  // 记录广告点击
  recordAdClick(adId) {
    wx.request({
      url: `${app.globalData.baseUrl}/api/ad/click`,
      method: 'POST',
      data: {
        ad_id: adId,
        user_id: this.data.userInfo?.id,
        position: 'profile'
      },
      success: (res) => {
        console.log('广告点击记录成功')
      },
      fail: (err) => {
        console.error('记录广告点击失败:', err)
      }
    })
  },

})
